//           historico.C
//  Ter julho 12 08:31:25 2011
//  Copyright  2011  Jónison Almeida dos Santos
//  <user@host>

#include <historico.h>
using namespace std;
using namespace Gtk::Menu_Helpers;
using namespace Gtk::Menu_Helpers;

/**
 *
 */
PLANILHA::PLANILHA()
	{
	add (this->descricao);
	add (this->reg);
	add (this->data);
	for(int i=0; i< 17; i++)
		{
		add(campo[i]);
		}
	}

/**
 *
 */
PLANILHA::~PLANILHA()
	{
	}

/**
 *
 */
HISTORICO::HISTORICO(bool *controle_historico , BANCOPG *conn)
	{
	this->conexao = conn;
	this->entry_ativa=0;
	this->controle_hist = controle_historico;
	janela_historico();
	}

/**
 *
 */
HISTORICO::~HISTORICO()
	{
	//Historico_Geral.hide();
	}

/**
 *
 */
void HISTORICO::Fechou_Janela()
	{
	*this->controle_hist = true;
	}

/**
 *
 */
void HISTORICO :: janela_historico ()
	{
	this->contar_data=0; //Inicializando o contador da verificação da data
	Historico_Geral.set_title(Glib::ustring("Seleção de Historico"));
	Historico_Geral.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
	Historico_Geral.set_position(Gtk::WIN_POS_CENTER);
	Historico_Geral.set_default_size(450, 400);
	Principal.set_homogeneous(true);		//DEFINE SE TODOS OS FILHOS TERÃO O MESMO TAMANHO DO BOX DO PAI
	Principal.set_spacing(0);
	Historico_Geral.signal_hide().connect(sigc::mem_fun (*this, &HISTORICO::Fechou_Janela));

	Box_Historico.set_homogeneous(true);		//DEFINE SE TODOS OS FILHOS TERÃO O MESMO TAMANHO DO BOX DO PAI
	Box_Historico.set_spacing(0);

	this->labgeral = new Gtk::Label(Glib::ustring("Selecione o Historico:")); //Usar COMBOBOX
	//this->ent_totalkg.set_size_request(80,28);
	//this->ent_totalkg.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Geral.pack_start(*labgeral,false,false,0);
	this->Box_Geral.pack_start(this->CB_Opcao,false,false,0);
	listar_dados(1); //Listar os tipos de historicos
	this->Box_Historico.pack_start(this->Box_Geral, false, false, 0);
	
	this->labgeral = new Gtk::Label(Glib::ustring("Apiario:")); //Usar COMBOBOX
	this->ent_apiario.set_size_request(450,28);
	
	//this->ent_apiario.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Geral2.pack_start(*labgeral,false,false,0);
	this->Box_Geral2.pack_start(this->ent_apiario,false,false,0);
	this->Box_Historico.pack_start(this->Box_Geral2, false, false, 0);
	listar_dados(2);

	Box_Geral3.set_homogeneous(true);		//DEFINE SE TODOS OS FILHOS TERÃO O MESMO TAMANHO DO BOX DO PAI
	Box_Geral3.set_spacing(0);
	//this->Gravar_Image = Gtk::manage(new Gtk::Image(Gtk::Stock::SAVE, Gtk::ICON_SIZE_BUTTON));
	Gerar.set_label("Abrir");
	Gerar.set_tooltip_text(Glib::ustring("Abrir o historico selecionado"));
			
	Gerar.signal_clicked().connect(sigc::mem_fun(*this, &HISTORICO::abrir_janela));
	this->Box_Geral3.pack_start(this->Gerar,false,false,0);
	this->Box_Historico.pack_start(this->Box_Geral3, false, false, 0);	
	
	this->Historico_Geral.add(Box_Historico);
	//this->Historico_Producao.add(this->VB_Producao);
	this->Historico_Geral.show_all();
	this->Historico_Geral.set_focus(ent_apiario);
	
	}

/**
 *
 */
void HISTORICO :: janela_producao ()
	{
	Historico_Producao.set_title(Glib::ustring("Historico de Produção"));
	Historico_Producao.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
	Historico_Producao.set_position(Gtk::WIN_POS_CENTER);
	Historico_Producao.set_default_size(850, 800);
	Principal.set_homogeneous(true);		//DEFINE SE TODOS OS FILHOS TERÃO O MESMO TAMANHO DO BOX DO PAI
	Principal.set_spacing(0);
	
	this->VB_Producao.set_homogeneous(false);
	this->VB_Producao.set_spacing(0);

	//******************************* EXIBIÇÃO DAS COMEIAS EM REVISÃO ************************************
	this->HB_Colmeias.set_homogeneous(false);

	this->CS_Historico.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
	
	this->CS_Historico.add(this->CT_Historico);
	this->HB_Colmeias.pack_start(this->CS_Historico);
	this->VB_Producao.pack_start(this->HB_Colmeias,true,true,0);

	
	visualizacao_treeview ();
	
	//********************************** CAMPO PARA PREENCHIMENTO DA PLANILHA DE CAMPO ************************
	this->Producao = new Gtk::Frame(Glib::ustring("Lançamentos: Planilha de Produção"));
	this->VB_Producao.set_homogeneous(false);
	this->VB_Producao.set_spacing(10);

	
	this->Box_Linha0.set_homogeneous(false);
	this->Box_Linha0.set_spacing(10);
	this->labgeral = new Gtk::Label(Glib::ustring("Número Planilha:")); //Usar COMBOBOX
	this->ent_Nump.set_size_request(80,28);
	this->ent_Nump.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Linha0.pack_start(*labgeral,false,false,0);
	this->Box_Linha0.pack_start(this->ent_Nump,false,false,5);
	this->labgeral = new Gtk::Label(Glib::ustring("Data Revisão")); //Usar COMBOBOX
	this->ent_DataRev.set_size_request(100,28);
	this->ent_DataRev.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Linha0.pack_start(*labgeral,false,false,0);
	this->Box_Linha0.pack_start(this->ent_DataRev,false,false,5);
	this->labgeral = new Gtk::Label(Glib::ustring("Hora Inicial:")); //Usar COMBOBOX
	this->ent_Horai.set_size_request(80,28);
	this->ent_Horai.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Linha0.pack_start(*labgeral,false,false,0);
	this->Box_Linha0.pack_start(this->ent_Horai,false,false,5);
	this->labgeral = new Gtk::Label(Glib::ustring("Hora Final:")); //Usar COMBOBOX
	this->ent_Horaf.set_size_request(80,28);
	this->ent_Horaf.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Linha0.pack_start(*labgeral,false,false,0);
	this->Box_Linha0.pack_start(this->ent_Horaf,false,false,5);
//	this->Box_Linha4.pack_start(this->CB_Lua);
	this->Box_Producao.pack_start(this->Box_Linha0, false, false, 10);
//	listar_dados(1);

	ent_Nump.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &HISTORICO::configuracao_datahora),5));
	ent_DataRev.set_max_length(10);
	ent_DataRev.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &HISTORICO::configuracao_datahora),1));
	ent_Horai.set_max_length(5);
	ent_Horaf.set_max_length(5);
	ent_Horai.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &HISTORICO::configuracao_datahora),2));
	ent_Horaf.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &HISTORICO::configuracao_datahora),3));

	ent_Nump.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&HISTORICO::setar_focus),&this->Historico_Producao,&this->ent_DataRev,3));
	ent_DataRev.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&HISTORICO::setar_focus),&this->Historico_Producao,&this->ent_Horai,2));
	ent_Horai.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&HISTORICO::setar_focus),&this->Historico_Producao,&this->ent_Horaf,5));
	ent_Horaf.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&HISTORICO::setar_focus),&this->Historico_Producao,&this->ent_Colmeia,6));

	this->Box_Linha1.set_homogeneous(false);
	this->Box_Linha1.set_spacing(0);
	
	this->labgeral = new Gtk::Label(Glib::ustring("Colmeia:"));
	this->ent_Colmeia.set_size_request(150,28);
	this->ent_Colmeia.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Linha1.pack_start(*labgeral,false,false,0);
	this->Box_Linha1.pack_start(ent_Colmeia,false,false,5);
	this->labgeral = new Gtk::Label(Glib::ustring("Nº Melg. Colhida:")); 
	this->ent_melgueiracol.set_size_request(80,28);
	this->ent_melgueiracol.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Linha1.pack_start(*labgeral,false,false,0);
	this->Box_Linha1.pack_start(this->ent_melgueiracol,false,false,5);
	this->labgeral = new Gtk::Label(Glib::ustring("Total KG:")); //Usar COMBOBOX
	this->ent_totalkg.set_size_request(80,28);
	this->ent_totalkg.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Linha1.pack_start(*labgeral,false,false,0);
	this->Box_Linha1.pack_start(this->ent_totalkg,false,false,5);
	this->Box_Producao.pack_start(this->Box_Linha1, false, false, 10);
	
	
	ent_Colmeia.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&HISTORICO::setar_focus),&this->Historico_Producao,&this->ent_melgueiracol,0));
	ent_melgueiracol.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&HISTORICO::setar_focus),&this->Historico_Producao,&this->ent_totalkg,1));
	ent_totalkg.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&HISTORICO::setar_focus),&this->Historico_Producao,&this->ent_melgremanes,0));
	listar_dados(5);

	this->Box_Linha2.set_homogeneous(false);
	this->Box_Linha2.set_spacing(10);
	this->labgeral = new Gtk::Label(Glib::ustring("Melg. Rem.:"));
	this->ent_melgremanes.set_size_request(80,28);
	this->ent_melgremanes.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Linha2.pack_start(*labgeral,false,false,0);
	this->Box_Linha2.pack_start(ent_melgremanes,false,false,5);
	this->labgeral = new Gtk::Label(Glib::ustring("KG Remanescente:")); 
	this->ent_kgremanes.set_size_request(80,28);
	this->ent_kgremanes.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Linha2.pack_start(*labgeral,false,false,0);
	this->Box_Linha2.pack_start(this->ent_kgremanes,false,false,5);
	this->labgeral = new Gtk::Label(Glib::ustring("Nota Colmeia:")); //Usar COMBOBOX
	//this->ent_nota.set_size_request(100,28);
	//this->ent_nota.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Linha2.pack_start(*labgeral,false,false,0);
	this->Box_Linha2.pack_start(this->CB_Nota,false,false,5);
	this->Box_Producao.pack_start(this->Box_Linha2, false, false, 0);
	listar_dados(3);
	ent_melgremanes.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&HISTORICO::setar_focus),&this->Historico_Producao,&this->ent_kgremanes,0));
	ent_kgremanes.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&HISTORICO::setar_focus),&this->Historico_Producao,&this->ent_nota,0));
	ent_nota.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&HISTORICO::setar_focus),&this->Historico_Producao,&this->ent_rainha,0));

	this->Box_Linha3.set_homogeneous(false);
	this->Box_Linha3.set_spacing(10);
	this->labgeral = new Gtk::Label(Glib::ustring("Rainha:")); 
	this->ent_rainha.set_size_request(100,28);
	this->ent_rainha.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Linha3.pack_start(*labgeral,false,false,0);
	this->Box_Linha3.pack_start(this->ent_rainha,false,false,5);
	this->labgeral = new Gtk::Label(Glib::ustring("Geração:")); 
	this->ent_geracao.set_size_request(70,28);
	this->ent_geracao.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Linha3.pack_start(*labgeral,false,false,0);
	this->Box_Linha3.pack_start(this->ent_geracao,false,false,5);

	this->labgeral = new Gtk::Label(Glib::ustring("Mãe:")); 
	this->ent_mae.set_size_request(70,28);
	this->ent_mae.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Linha3.pack_start(*labgeral,false,false,0);
	this->Box_Linha3.pack_start(this->ent_mae,false,false,5);
	
	this->labgeral = new Gtk::Label(Glib::ustring("Data Introdução:"));
	this->ent_intro.set_size_request(100,28);
	this->ent_intro.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Linha3.pack_start(*labgeral,false,false,0);
	this->Box_Linha3.pack_start(ent_intro,false,false,5);
	this->ent_intro.set_max_length(10);
	this->labgeral = new Gtk::Label(Glib::ustring("Situação:")); //Usar COMBOBOX
	//this->ent_situacao.set_size_request(70,28);
	//this->ent_situacao.set_alignment (Gtk::ALIGN_CENTER);
	this->Box_Linha3.pack_start(*labgeral,false,false,0);
	this->Box_Linha3.pack_start(this->CB_Situacao,false,false,5);
	listar_dados(4);

	ent_geracao.set_editable(false);
	ent_mae.set_editable(false);
	this->Box_Producao.pack_start(this->Box_Linha3, false, false, 10);	
	listar_dados(6);
	ent_intro.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &HISTORICO::configuracao_datahora),4));
	ent_rainha.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&HISTORICO::setar_focus),&this->Historico_Producao,&this->ent_intro,4));
	//ent_geracao.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&HISTORICO::setar_focus),&this->Historico_Producao,&this->ent_intro,0));
	ent_intro.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&HISTORICO::setar_focus),&this->Historico_Producao,&this->ent_situacao,2));
	ent_situacao.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&HISTORICO::setar_focus),&this->Historico_Producao,&this->TV_obs,0));
	
	this->Box_Linha5.set_homogeneous(false);
	this->Box_Linha5.set_spacing(10);

	this->labgeral = new Gtk::Label(Glib::ustring("OBS:"));
	this->Box_Linha5.pack_start(*labgeral,false,false,0);
	SW_obs.add(TV_obs);
	SW_obs.set_size_request(500,48);
	//Irá mostrar a barra de rolagem somente quando for necessário
	SW_obs.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
	this->Box_Linha5.pack_start(this->SW_obs,false,false,0);
	this->Box_Producao.pack_start(this->Box_Linha5, false, false, 20);

	this->Box_Linha6.set_homogeneous(false);
	this->Box_Linha6.set_spacing(10);
	this->Gravar_Image = Gtk::manage(new Gtk::Image(Gtk::Stock::SAVE, Gtk::ICON_SIZE_BUTTON));
	Gravar.set_label("Gravar");
	Gravar.set_image(*Gravar_Image);
	Gravar.set_tooltip_text(Glib::ustring("Salva as informações"));
	Gravar.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &HISTORICO::armazenar_registro), 1));

	Limpar.set_label("Limpar Dados");
	Limpar.set_tooltip_text(Glib::ustring("Limpar informações"));
	Limpar.signal_clicked().connect(sigc::mem_fun(*this, &HISTORICO::limpar_janela));
	
	this->Box_Linha6.pack_start(this->Gravar,false,false,0);
	this->Box_Linha6.pack_start(this->Limpar,false,false,0);

	this->Box_Producao.pack_start(this->Box_Linha6, false, false, 0);

	this->Producao->add(Box_Producao);
	
	this->VB_Producao.pack_start(*this->Producao,true,true,0);

	this->Historico_Producao.add(this->VB_Producao);
	this->Historico_Producao.show_all();
	this->Historico_Producao.set_focus(ent_Nump); //O focus da janela deve ser setado na entry sempre depois que ela for carregada

	}	

/**
 * \param w
 * \param n
 */
void HISTORICO :: set_posicao (Gtk::Entry * w, int n)
	{
	Glib::signal_idle().connect
    	(sigc::bind_return
           (sigc::bind<int>
               (sigc::mem_fun (*w,&Gtk::Entry::set_position), n), false));
	}

/**
 * \param janela
 * \param destino
 * \param soma
 */
void HISTORICO :: setar_focus (Gtk::Window *janela, Gtk::Widget *destino, int soma)
	{
	bool controle[1];
	int total_melgueiras;
	char *total_geral, *sql, *Data_formatada;
	string var_aux, SQL, Aux, abelha_rainha;
	vector<string> linha;
	
	switch (soma)
		{
		case 1:
			{
			total_melgueiras = 10*atoi(ent_melgueiracol.get_text().c_str());
			total_geral = new char[32];
			sprintf(total_geral,"%d",total_melgueiras);
			ent_totalkg.set_text(total_geral);
			delete total_geral;
			janela->set_focus(*destino);
			break;
			}
		case 2:
			{
			contar_data=0;
			var_aux.clear();
			var_aux = this->ent_DataRev.get_text();
			if(var_aux.length()<10)
				{
				Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
				Confirma.set_secondary_text("Entre com a data correta");
				Confirma.set_position(Gtk::WIN_POS_CENTER);
				Confirma.run();
				this->Historico_Producao.set_focus(ent_DataRev);				
				}
			else{
				janela->set_focus(*destino);
				}
		//contar_data=0;
			
			break;
			}
		case 3:
			{
			//verificando se a planilha esta cadastrada no apiario desejado
			SQL.clear();
			SQL = "select nump, data from cadastro.planilhas where nump=";
			SQL += ent_Nump.get_text();
			SQL += " and apiario= ";
			SQL += this->cod_apiario;
			sql = new char[SQL.length()+1];
			strcpy(sql, SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			if(this->conexao->registros == 0 || ent_Nump.get_text_length()==0 )
				{
				Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
				Confirma.set_secondary_text("Entre com o Número da Planilha valido!!");
				Confirma.set_position(Gtk::WIN_POS_CENTER);
				Confirma.run();
				this->Historico_Producao.set_focus(ent_Nump);
				}
			else
				{
				this->conexao->resultado();
				linha = this->conexao->resultados.at(0);
				Aux.clear();
				Aux = linha.at(1);
			//	cout<<Aux<<" TEstde da primeira data  ";
				Data_formatada = new char[Aux.length()+1];	
				strcpy(Data_formatada,Aux.c_str());
				//cout<<Data_formatada<<endl;
				Aux.clear();
				Aux = data_formatada(Data_formatada, 2);
				delete Data_formatada;
				cout<<Aux<<endl;
				this->ent_DataRev.set_text(Glib::ustring(Aux));
				
				SQL.clear();
				SQL = "select * from historico.producao where id_planilha=";
				SQL += ent_Nump.get_text();
				sql = new char[SQL.length()+1];
				strcpy(sql, SQL.c_str());
				this->conexao->executar(sql);
				cout<<sql<<endl<<this->conexao->registros<<endl;
				delete sql;
			//	if(this->registros == 0 )
				//	{
				janela->set_focus(*destino);
					
				//	}
			/*	else
					{
					Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
					Confirma.set_secondary_text("Este número da planilha já foi cadastrado!!");
					Confirma.set_position(Gtk::WIN_POS_CENTER);
					Confirma.run();
					this->Historico_Producao.set_focus(ent_Nump);
					}*/
				}
			break;
			}
		case 4:
			{
			abelha_rainha.clear();
			abelha_rainha = ent_rainha.get_text();
			SQL.clear();
			SQL = "select geracao, cod_atual from cadastro.abelha_rainha where cod_novo ='"+ abelha_rainha +"'";
			sql = new char[SQL.length()+1];
			strcpy(sql, SQL.c_str());
			this->conexao->executar(sql);
			if(this->conexao->registros>0)
				{
				this->conexao->resultado();
				linha = this->conexao->resultados.at(0);
				this->ent_geracao.set_text(linha.at(0));
				this->ent_mae.set_text(linha.at(1));
				cout<<sql<<endl;
				delete sql;
				janela->set_focus(*destino);
				}
			else
				{
				Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
				Confirma.set_secondary_text("Abelha Rainha não Cadastrada! Cadastre -a primeiro!");
				Confirma.set_position(Gtk::WIN_POS_CENTER);
				Confirma.run();
				Confirma.hide();
				controle[0]=true;
				CADASTRO cadastro(6, &controle[0],this->conexao);
				cadastro.Abelha_Rainha->show_all();
				Gtk::Main::run(*cadastro.Abelha_Rainha);
				listar_dados(6);
		
				//this->janela=6;
				//this->carregar_primeiro();
				}
			break;
			}
		case 5:
			{
			var_aux.clear();
			var_aux = this->ent_Horai.get_text();
			if(var_aux.length()<5)
				{
				Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
				Confirma.set_secondary_text("Entre com hora inicial correta!");
				Confirma.set_position(Gtk::WIN_POS_CENTER);
				Confirma.run();
				this->Historico_Producao.set_focus(ent_Horai);				
				}
			else{
				janela->set_focus(*destino);
				}
			break;
			}
		case 6:
			{
			var_aux.clear();
			var_aux = this->ent_Horaf.get_text();
			if(var_aux.length()<5)
				{
				Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
				Confirma.set_secondary_text("Entre com hora inicial correta!");
				Confirma.set_position(Gtk::WIN_POS_CENTER);
				Confirma.run();
				this->Historico_Producao.set_focus(ent_Horaf);				
				}
			else{
				janela->set_focus(*destino);
				}
			break;
			}
		default:
			{
			janela->set_focus(*destino);
			break;
			}
		}
	}

/**
 * Seta as mascaras das datas e no case 7 deixa a entry rg da rainha aceitando somente numeros
 * \param opc
 */
void HISTORICO :: configuracao_datahora(int opc)  
	{
	string aux;
	int len;
	int teste; //variavel que pega a posicao do texto na entry
	string mascara, saida;
	int j;
	bool mudou;
	mudou = false;
	mascara.clear();
	if(entry_ativa != opc)
		{
		this->entry_ativa = opc;
		mudou = true;
		}
	switch (opc)
		{
		case 1:
			{
			if(mudou)
				{
				this->len_ant = ent_DataRev.get_text_length();
				}
			mascara = "##/##/####";
			//this->contar_data=contar_data+1;
			aux.clear();
			aux = this->ent_DataRev.get_text();
			cout << aux << endl;
			len = aux.length();
			if(isdigit(aux[len-1]) || (aux[len-1] == '/'))  //para aceitar alem dos numeros o caracter virgula
				{
				if ((len_ant > 0) && (len_ant > len))
					{
					len_ant--;
					aux[len]='\0';
					}
				else if (len < 10)
					{
					if(mascara[len] !='#')
						{
						aux += mascara [len];
						}
					//cout << aux[len-1] << " = " << aux[len-2] << endl;
					if((aux[len-1] == '/')&&(aux[len-2] == '/'))
						{
						aux[len-1] = '\0';
						}
					len++;
					}
				
				}
			else
				{
				aux[len-1]='\0';
				len--;
				}
			cout << aux << endl;
			this->ent_DataRev.set_text(Glib::ustring(aux));
			this->set_posicao(&this->ent_DataRev, len);
			this->len_ant=len;
			break;	
			}
		case 2:
			{
			if(mudou)
				{
				this->len_ant = ent_Horai.get_text_length();
				}
			mascara = "##:##";
			aux.clear();	
			aux = this->ent_Horai.get_text();
			len = aux.length();
			if(isdigit(aux[len-1]) || (aux[len-1] == ':'))  //para aceitar alem dos numeros o caracter virgula
				{
				if ((len_ant > 0) && (len_ant > len))
					{
					len_ant--;
					aux[len]='\0';
					}
				else if (len < 4)
					{
					if(mascara[len] !='#')
						{
						aux += mascara [len];
						}
				if((aux[len-1] == ':')&&(aux[len-2] == ':'))
						{
						aux[len-1] = '\0';
						}
					len++;
					}
				
				}
			else
				{
				aux[len-1]='\0';
				len--;
				}
			this->ent_Horai.set_text(aux);
					set_posicao(&this->ent_Horai,len+1);//tirei o len+1 pra testar
				len_ant = len;
			break;
			}
		case 3:
			{
			if(mudou)
				{
				this->len_ant = ent_Horaf.get_text_length();
				}
			aux.clear();
			mascara = "##:##";
			aux = this->ent_Horaf.get_text();
			len = aux.length();
			if(isdigit(aux[len-1]) || (aux[len-1] == ':'))  //para aceitar alem dos numeros o caracter virgula
				{
				if ((len_ant > 0) && (len_ant > len))
					{
					len_ant--;
					aux[len_ant]='\0';
					}
				else if (len < 4)
					{
					if(mascara[len] !='#')
						{
						aux += mascara [len];
						}
				if((aux[len-1] == ':')&&(aux[len-2] == ':'))
						{
						aux[len-1] = '\0';
						}
					this->ent_Horaf.set_text(aux);
					set_posicao(&this->ent_Horaf,len+1); //tirei o len+1 pra testar
					}
				len_ant = len;
				}
			else
				{
				aux[len-1]='\0';
				this->ent_Horaf.set_text(aux);
				}
			break;
			}
		case 4:
			{
			if(mudou)
				{
				this->len_ant = ent_intro.get_text_length();
				}
			mascara = "##/##/####";
						//this->contar_data=contar_data+1;
			aux.clear();
			aux = this->ent_intro.get_text();
			len = aux.length();
			if(isdigit(aux[len-1]) || (aux[len-1] == '/'))  //para aceitar alem dos numeros o caracter virgula
				{
				if ((len_ant > 0) && (len_ant > len))
					{
					len_ant--;
					aux[len_ant]='\0';
					}
				else if (len < 10)
					{
					if(mascara[len] !='#')
						{
						aux += mascara [len];
						}
					//cout << aux[len-1] << " = " << aux[len-2] << endl;
					if((aux[len-1] == '/')&&(aux[len-2] == '/'))
						{
						aux[len-1] = '\0';
						}
					this->ent_intro.set_text(aux);
			  	    set_posicao(&this->ent_intro,len+1);
					}
				len_ant = len;
				}
			else
				{
				aux[len-1]='\0';
				this->ent_intro.set_text(aux);
				}
			break;	
			}
		case 5:
			{
			aux.clear();
			aux = this->ent_Nump.get_text();
			len = aux.length();
			if(isdigit(aux[len-1])) 
				{
				//aux.clear();
				this->ent_Nump.set_text(aux);
				}
			else
				{
					aux[len-1]='\0';
					this->ent_Nump.set_text(aux);
				}
			break;
			}
		}
	}

/**
 * \param opc
 */
void HISTORICO :: listar_dados( int opc)
	{
	int i,total;
	char *sql, *concatena, *Data_formatada;
	string SQL, AUX, apiario, ab_rainha, Aux;
	vector<vector<string> >::iterator ir;
	vector<string> linha;
	switch (opc)
		{
		case 1:
			{
			CB_Opcao.clear();
			opcao_lista = Gtk::ListStore::create(Planilha_Reg);
			CB_Opcao.set_model(opcao_lista);
			celula = *(opcao_lista->append());
			celula[Planilha_Reg.reg] = 0;
			celula[Planilha_Reg.descricao]= " ";
			celula = *(opcao_lista->append());
			celula[Planilha_Reg.reg] = 1;
			celula[Planilha_Reg.descricao]= Glib::ustring("Historico de Produção");
			celula = *(opcao_lista->append());
			celula[Planilha_Reg.reg] = 2;
			celula[Planilha_Reg.descricao]= Glib::ustring("Historico de Desenvolvimento");
			celula = *(opcao_lista->append()); 
			CB_Opcao.set_active(1);
			break;
			}
		case 2:
			{
			Glib::RefPtr<Gtk::EntryCompletion> completion =  Gtk::EntryCompletion::create();
			apiario_lista = Gtk::ListStore::create(Planilha_Reg);
			completion->set_model(apiario_lista);
			ent_apiario.set_completion(completion);
			SQL.clear();
			SQL = "select id_api,nome,local,sub_regiao from cadastro.apiarios order by nome";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			total=this->conexao->registros;
			this->conexao->resultado();
			for(ir=this->conexao->resultados.begin();ir<this->conexao->resultados.end();ir++)
				{
				linha = *ir;
				apiario.clear();
				celula = *(apiario_lista->append());
				celula[Planilha_Reg.reg] = atoi(linha.at(0).c_str());
				//celula[arvore_reg.contador] = this->resultado(i,0);
				//apiario = this->resultado(i,0);
				apiario=linha.at(1);
				apiario+= "/";
				apiario+= linha.at(2);
				apiario+= "/"; 
				apiario+= linha.at(3);
				apiario+= "<";
				apiario+= linha.at(0);
				apiario+=">";
				celula[Planilha_Reg.descricao]= apiario;
				}
			completion->set_text_column(Planilha_Reg.descricao);

			for(type_actions_map::iterator iter = m_CompletionActions.begin();iter != m_CompletionActions.end(); ++iter)
				{
				int position = iter->first;
				Glib::ustring title = iter->second;
				completion->insert_action_text(title, position);
				}
			break;
			}
		case 3:
			{
			CB_Nota.clear();
			nota_lista = Gtk::ListStore::create(Planilha_Reg);
			CB_Nota.set_model(nota_lista);
			celula = *(nota_lista->append());
			celula[Planilha_Reg.reg] = 0;
			celula[Planilha_Reg.descricao]= " ";
			celula = *(nota_lista->append());
			celula[Planilha_Reg.reg] = 1;
			celula[Planilha_Reg.descricao]= Glib::ustring("Ótima");
			celula = *(nota_lista->append());
			celula[Planilha_Reg.reg] = 2;
			celula[Planilha_Reg.descricao]= Glib::ustring("Boa");
			celula = *(nota_lista->append()); 
			celula[Planilha_Reg.reg] = 3;
			celula[Planilha_Reg.descricao]= Glib::ustring("Ruim");
			celula = *(nota_lista->append());
			celula[Planilha_Reg.reg] = 4;
			celula[Planilha_Reg.descricao]= Glib::ustring("Avaliar");
			celula = *(nota_lista->append()); 
			CB_Nota.set_active(0);
			break;
			}
		case 4:
			{
			CB_Situacao.clear();
			situacao_lista = Gtk::ListStore::create(Planilha_Reg);
			CB_Situacao.set_model(situacao_lista);
			celula = *(situacao_lista->append());
			celula[Planilha_Reg.reg] = 0;
			celula[Planilha_Reg.descricao]= " ";
			celula = *(situacao_lista->append());
			celula[Planilha_Reg.reg] = 1;
			celula[Planilha_Reg.descricao]= Glib::ustring("Puxada Natural");
			celula = *(situacao_lista->append());
			celula[Planilha_Reg.reg] = 2;
			celula[Planilha_Reg.descricao]= Glib::ustring("Zanganeira");
			celula = *(situacao_lista->append()); 
			celula[Planilha_Reg.reg] = 3;
			celula[Planilha_Reg.descricao]= Glib::ustring("Enxameação");
			celula = *(situacao_lista->append());
			celula[Planilha_Reg.reg] = 4;
			celula[Planilha_Reg.descricao]= Glib::ustring("Rainha Fecundada");
			celula = *(situacao_lista->append());
			celula[Planilha_Reg.reg] = 5;
			celula[Planilha_Reg.descricao]= Glib::ustring("Trocar Rainha");
			celula = *(situacao_lista->append());
			
			CB_Situacao.set_active(0);
			break;
			}
		case 5:
			{
			this->id_colmeia.clear();
			Glib::RefPtr<Gtk::EntryCompletion> completion =  Gtk::EntryCompletion::create();
			colmeia_lista = Gtk::ListStore::create(Planilha_Reg);
			completion->set_model(colmeia_lista);
			ent_Colmeia.set_completion(completion);
			SQL.clear();
			SQL = "select id_col,data_form from cadastro.colmeias order by id_col";
			sql = new char[SQL.length()+1];
			strcpy(sql, SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			total=this->conexao->registros;
			this->conexao->resultado();
			for(ir=this->conexao->resultados.begin();ir<this->conexao->resultados.end();ir++)
				{
				linha = *ir;
				apiario.clear();
				celula = *(colmeia_lista->append());
				celula[Planilha_Reg.reg] = atoi(linha.at(0).c_str());
				apiario= linha.at(0);
				apiario+= "  ";
				Aux.clear();
				Aux = linha.at(1);
				Data_formatada = new char[Aux.length()+1];	
				strcpy(Data_formatada,Aux.c_str());
				apiario+=data_formatada(Data_formatada, 2);
				delete Data_formatada;
				celula[Planilha_Reg.descricao]= apiario;
				}
			
			completion->set_text_column(Planilha_Reg.descricao);

			for(type_actions_map::iterator iter = m_CompletionActions.begin();iter != m_CompletionActions.end(); ++iter)
				{
				int position = iter->first;
				Glib::ustring title = iter->second;
				completion->insert_action_text(title, position);
				}
			break;
			}
		case 6:
			{
			this->id_abelharainha.clear();
			Glib::RefPtr<Gtk::EntryCompletion> completion =  Gtk::EntryCompletion::create();
			abelharainha_lista = Gtk::ListStore::create(Planilha_Reg);
			completion->set_model(abelharainha_lista);
			ent_rainha.set_completion(completion);

			SQL.clear();
			SQL = "select cod_novo from cadastro.abelha_rainha order by cod_novo";
			sql = new char[SQL.length()+1];
			strcpy(sql, SQL.c_str());
			cout<<sql<<endl;
			this->conexao->executar(sql);
			delete sql;
			total=this->conexao->registros;
			this->conexao->resultado();
			for(ir=this->conexao->resultados.begin();ir<this->conexao->resultados.end();ir++)
				{					
				linha = *ir;
				ab_rainha.clear();
				celula = *(abelharainha_lista->append());
				celula[Planilha_Reg.reg] = atoi(linha.at(0).c_str());
				ab_rainha=linha.at(0);
				celula[Planilha_Reg.descricao]= ab_rainha;
				}
			
			completion->set_text_column(Planilha_Reg.descricao);

			for(type_actions_map::iterator iter = m_CompletionActions.begin();iter != m_CompletionActions.end(); ++iter)
				{
				int position = iter->first;
				Glib::ustring title = iter->second;
				completion->insert_action_text(title, position);
				}
			break;
			}

		}
	}

/**
 * \param janela_selecionada
 */
void HISTORICO :: armazenar_registro(int janela_selecionada)
	{
	char *sql, *sqltemp, *aux, *Data_formatada;
	int pos_atual, i, j, auxid_col, auxstatus, result;
	bool resposta;
	int contaux;
	string var_aux, cidade, SQL, SQLTEMP, colmeia;
	
	
	Gtk::TreeModel::iterator contador;
	Gtk::TreeModel::Row registro;
	var_aux.clear();
	
	if(ent_Nump.get_text_length() > 0 && ent_Colmeia.get_text_length() > 0 && ent_DataRev.get_text_length() > 0  && ent_rainha.get_text_length() > 0)
		{
		SQLTEMP.clear();
		SQLTEMP = "select * from historico.producaotemp where id_colmeia= ";
		SQL.clear();
		SQL = "insert into historico.producao (id_planilha, id_apiario, id_colmeia,data_formacao,";
		SQL += "data_revisao, horai, horaf, melg_colh, total_kg_colh, melg_remanes, kg_remanes, data_introducao, rainha, geracao,  situacao, nota, obs, cod_mae) values (";

		var_aux = this->ent_Nump.get_text();  //Pegando Numero da planilha
		SQL += var_aux + ",";
		SQL.append(cod_apiario);
		SQL += ",";

		//Pegando o numero da colmeia e a data de formação da mesma
		this->id_colmeia.clear();
		this->id_colmeia= ent_Colmeia.get_text();
		colmeia.clear();
		
		contaux = this->id_colmeia.find(" ");
		if (contaux!= string::npos)
			{
			SQL += id_colmeia.substr(0,contaux);
			SQLTEMP += id_colmeia.substr(0,contaux); //para fazer a busca de registro da tabela histprodtemp
			}
		SQL += ",'";
		this->data_form.clear();
		this->data_form = this->id_colmeia.substr(contaux+2,this->id_colmeia.length());

		Data_formatada = new char[this->data_form.length()+1];	
		strcpy(Data_formatada,this->data_form.c_str());
		SQL.append(data_formatada(Data_formatada, 1));
		SQLTEMP += " and data_formacao='";  //pegando data de formação da colmeia para buscar os valores no hit.produtemp
		SQLTEMP.append(data_formatada(Data_formatada, 1));
		SQLTEMP += "'";

		delete Data_formatada;
		
		SQL += "','";
	
		var_aux.clear();
		var_aux = this->ent_DataRev.get_text();			//Pegando a data de Revisão 
		Data_formatada = new char[var_aux.length()+1];	
		strcpy(Data_formatada,var_aux.c_str());
		SQL.append(data_formatada(Data_formatada, 1));
		delete Data_formatada;
		SQL += "','";

		var_aux.clear();
		var_aux = this->ent_Horai.get_text();  //Pegando a Hora Inicial
		SQL  += var_aux +"','";	

		var_aux.clear();
		var_aux = this->ent_Horaf.get_text();  //Pegando a Hora Final
		SQL  += var_aux +"',";	

		//melg_colh, total_kg_colh, melg_remanes, kg_remanes, data_intro, rainha, geracao, situacao, nota)

		var_aux.clear();
		var_aux = this->ent_melgueiracol.get_text();  //Pegando numero de Melgueiras Colhidas
		SQL += var_aux+",";

		var_aux.clear();
		var_aux = this->ent_totalkg.get_text();  //Pegando numero de de KG colhido
		SQL += var_aux+",";

		var_aux.clear();
		var_aux = this->ent_melgremanes.get_text();  //Pegando numero de Melgueiras Remanescentes
		SQL += var_aux+",";

		var_aux.clear();
		var_aux = this->ent_kgremanes.get_text();  //Pegando numero de KG Remanescentes
		SQL += var_aux +",'";

		var_aux.clear();
		var_aux = this->ent_intro.get_text();			//Pegando a data de Introdução
		Data_formatada = new char[var_aux.length()+1];	
		strcpy(Data_formatada,var_aux.c_str());
		SQL.append(data_formatada(Data_formatada, 1));
		delete Data_formatada;
		SQL += "','";

		var_aux.clear();
		var_aux = this->ent_rainha.get_text();  //Pegando a Identificação da Rainha
		SQL += var_aux + "','";

		var_aux.clear();
		var_aux = this->ent_geracao.get_text();  //Pegando a Geração
		SQL += var_aux + "',";

		contador = this->CB_Situacao.get_active();		//Pegando Situação
		if(contador)
			{
			registro=*contador;
			if(registro)
				{
				this->cod_situacao=registro[Planilha_Reg.reg];
				}
			}
		aux = new char[32];
		sprintf(aux,"%d",this->cod_situacao);
		SQL.append(aux);
		delete aux;
		SQL += ",";
	
		contador = this->CB_Nota.get_active();		//Pegando Nota
		if(contador)
			{
			registro=*contador;
			if(registro)
				{
				this->cod_nota=registro[Planilha_Reg.reg];
				}
			}
		aux = new char[32];
		sprintf(aux,"%d",this->cod_nota);
		SQL.append(aux);
		SQL += ",'";

		this->TB_Obs = Gtk::TextBuffer::create ();
		this->TB_Obs = TV_obs.get_buffer();  //ponteiro pega o buffer e para pegar o texto que tem no buffer usa se o ponteiro com get_text
		var_aux.clear();
		var_aux= this->TB_Obs->get_text();
		SQL += var_aux + "',";
			
		var_aux.clear();
		var_aux = this->ent_mae.get_text();  //Pegando a Mae
		SQL += var_aux + ")";
		sql = new char[SQL.length()+1];
		strcpy(sql,SQL.c_str());
		this->conexao->executar(sql);
		if (this->conexao->query_result == 3)
			{
			cout << this->conexao->mensagem << endl;
			}
		cout<<sql<<endl;
		delete sql;
	
		//****************************Inserindo dados na planilha temporaria, para exibição na treeview********************************
		sqltemp = new char[SQLTEMP.length()+1];
		strcpy(sqltemp,SQLTEMP.c_str());
		this->conexao->executar(sqltemp);
		//cout<<"Testando a porra do sql temp    "<<this->registros<<"     "<<sqltemp<<endl;
		cout<<sqltemp<<endl;
		delete sqltemp;
		if(this->conexao->registros > 0)
			{
			//cout<<"cheguei aqui no if da temp"<<endl;
			SQL.clear();
			SQL = "update historico.producaotemp set id_planilha=";
			var_aux = this->ent_Nump.get_text();  //Pegando Numero da planilha
			SQL += var_aux + ", data_revisao='";	
			var_aux.clear();
			var_aux = this->ent_DataRev.get_text();			//Pegando a data de Revisão 
			Data_formatada = new char[var_aux.length()+1];	
			strcpy(Data_formatada,var_aux.c_str());
			SQL.append(data_formatada(Data_formatada, 1));
			delete Data_formatada;
				
			SQL += "', horai='";
			var_aux.clear();
			var_aux = this->ent_Horai.get_text();  //Pegando a Hora Inicial
			SQL += var_aux + "', horaf='";	
			var_aux.clear();
			var_aux = this->ent_Horaf.get_text();  //Pegando a Hora Final
			SQL += var_aux + "',melg_colh=";

			var_aux.clear();
			var_aux = this->ent_melgueiracol.get_text();  //Pegando numero de Melgueiras Colhidas
			SQL += var_aux + ",total_kg_colh=";

			var_aux.clear();
			var_aux = this->ent_totalkg.get_text();  //Pegando numero de de KG colhido
			SQL += var_aux + ",melg_remanes=";

			var_aux.clear();
			var_aux = this->ent_melgremanes.get_text();  //Pegando numero de Melgueiras Remanescentes
			SQL += var_aux + ",kg_remanes=";
//data_intro, rainha, geracao, situacao, nota)
			var_aux.clear();
			var_aux = this->ent_kgremanes.get_text();  //Pegando numero de KG Remanescentes
			SQL += var_aux + ",data_introducao='";

			var_aux.clear();
			var_aux = this->ent_intro.get_text();			//Pegando a data de Introdução
			Data_formatada = new char[var_aux.length()+1];	
			strcpy(Data_formatada,var_aux.c_str());
			SQL.append(data_formatada(Data_formatada, 1));
			delete Data_formatada;
			SQL += "',rainha='";

			var_aux.clear();
			var_aux = this->ent_rainha.get_text();  //Pegando a Identificação da Rainha
			SQL += var_aux + "',geracao='";

			var_aux.clear();
			var_aux = this->ent_geracao.get_text();  //Pegando a Geração
			SQL += var_aux + "',cod_mae=";

			var_aux.clear();
			var_aux = this->ent_mae.get_text();  //Pegando a Geração
			SQL += var_aux + ",situacao=";

			contador = this->CB_Situacao.get_active();		//Pegando Situação
			if(contador)
				{
				registro=*contador;
				if(registro)
					{
					this->cod_situacao=registro[Planilha_Reg.reg];
					}
				}
			aux = new char[32];
			sprintf(aux,"%d",this->cod_situacao);
			SQL.append(aux);
			delete aux;
			SQL += ",nota=";
	
			contador = this->CB_Nota.get_active();		//Pegando Nota
			if(contador)
				{
				registro=*contador;
				if(registro)
					{
					this->cod_nota=registro[Planilha_Reg.reg];
					}
				}
			aux = new char[32];
			sprintf(aux,"%d",this->cod_nota);
			SQL.append(aux);
			delete aux;
			SQL += ", obs='";

			this->TB_Obs = Gtk::TextBuffer::create ();
			this->TB_Obs = TV_obs.get_buffer();  //ponteiro pega o buffer e para pegar o texto que tem no buffer usa se o ponteiro com get_text
			var_aux.clear();
			var_aux= this->TB_Obs->get_text();
			SQL += var_aux + "' where id_apiario=";
			SQL.append(cod_apiario);  //Pegando numero do Apiario
				
			SQL += " and id_colmeia=";
			//Pegando o numero da colmeia e a data de formação da mesma
			this->id_colmeia.clear();
			this->id_colmeia= ent_Colmeia.get_text();
			colmeia.clear();
			contaux= this->id_colmeia.find(" ");
			if (contaux!= string::npos)
				{
				SQL += id_colmeia.substr(0,contaux);
				}
			SQL += " and data_formacao='";
			this->data_form.clear();
			this->data_form = this->id_colmeia.substr(contaux+2,this->id_colmeia.length());

			Data_formatada = new char[this->data_form.length()+1];	
			strcpy(Data_formatada,this->data_form.c_str());
			SQL.append(data_formatada(Data_formatada, 1));
			delete Data_formatada;
			SQL += "'";
			//cout<<"Testando update    "<<sql<<endl;
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			}
		else
			{
			//cout<<"cheguei aqui no else da temp"<<endl;
			SQL.clear();
			SQL = "insert into historico.producaotemp (id_planilha, id_apiario, id_colmeia,data_formacao,";
			SQL += "data_revisao, horai, horaf, melg_colh, total_kg_colh, melg_remanes, kg_remanes, data_introducao, rainha, geracao, cod_mae, situacao, nota, obs) values (";

			var_aux = this->ent_Nump.get_text();  //Pegando Numero da planilha
			SQL += var_aux + ",";

			SQL.append(cod_apiario);  //Pegando numero do Apiario
			SQL += ",";

			//Pegando o numero da colmeia e a data de formação da mesma
			this->id_colmeia.clear();
			this->id_colmeia= ent_Colmeia.get_text();
			colmeia.clear();
			contaux= this->id_colmeia.find(" ");
			if (contaux!= string::npos)
				{
				SQL += id_colmeia.substr(0,contaux);
				}
			SQL += ",'";
			this->data_form.clear();
			this->data_form = this->id_colmeia.substr(contaux+2,this->id_colmeia.length());

			Data_formatada = new char[this->data_form.length()+1];	
			strcpy(Data_formatada,this->data_form.c_str());
			SQL.append(data_formatada(Data_formatada, 1));
			delete Data_formatada;
		
			SQL += "','";
	
			var_aux.clear();
			var_aux = this->ent_DataRev.get_text();			//Pegando a data de Revisão 
			Data_formatada = new char[var_aux.length()+1];	
			strcpy(Data_formatada,var_aux.c_str());
			SQL.append(data_formatada(Data_formatada, 1));
			delete Data_formatada;
			SQL += "','";

			var_aux.clear();
			var_aux = this->ent_Horai.get_text();  //Pegando a Hora Inicial
			SQL += var_aux + "','";

			var_aux.clear();
			var_aux = this->ent_Horaf.get_text();  //Pegando a Hora Final
			SQL += var_aux + "',";

			//melg_colh, total_kg_colh, melg_remanes, kg_remanes, data_intro, rainha, geracao, situacao, nota)

			var_aux.clear();
			var_aux = this->ent_melgueiracol.get_text();  //Pegando numero de Melgueiras Colhidas
			SQL += var_aux + ",";

			var_aux.clear();
			var_aux = this->ent_totalkg.get_text();  //Pegando numero de de KG colhido
			SQL += var_aux + ",";

			var_aux.clear();
			var_aux = this->ent_melgremanes.get_text();  //Pegando numero de Melgueiras Remanescentes
			SQL += var_aux + ",";

			var_aux.clear();
			var_aux = this->ent_kgremanes.get_text();  //Pegando numero de KG Remanescentes
			SQL += var_aux + ",'";

			var_aux.clear();
			var_aux = this->ent_intro.get_text();			//Pegando a data de Introdução
			Data_formatada = new char[var_aux.length()+1];	
			strcpy(Data_formatada,var_aux.c_str());
			SQL.append(data_formatada(Data_formatada, 1));
			delete Data_formatada;
			SQL += "','";

			var_aux.clear();
			var_aux = this->ent_rainha.get_text();  //Pegando a Identificação da Rainha
			SQL += var_aux + "','";

			var_aux.clear();
			var_aux = this->ent_geracao.get_text();  //Pegando a Geração
			SQL += var_aux + "',";

			var_aux.clear();
			var_aux = this->ent_mae.get_text();  //Pegando a Geração
			SQL += var_aux + ",";

			contador = this->CB_Situacao.get_active();		//Pegando Situação
			if(contador)
				{
				registro=*contador;
				if(registro)
					{
					this->cod_situacao=registro[Planilha_Reg.reg];
					}
				}
			aux = new char[32];
			sprintf(aux,"%d",this->cod_situacao);
			SQL.append(aux);
			delete aux;
			SQL += ",";
	
			contador = this->CB_Nota.get_active();		//Pegando Nota
			if(contador)
				{
				registro=*contador;
				if(registro)
					{
					this->cod_nota=registro[Planilha_Reg.reg];
					}
				}
			aux = new char[32];
			sprintf(aux,"%d",this->cod_nota);
			SQL.append(aux);
			delete aux;
			SQL += ",'";

			this->TB_Obs = Gtk::TextBuffer::create ();
			this->TB_Obs = TV_obs.get_buffer();  //ponteiro pega o buffer e para pegar o texto que tem no buffer usa se o ponteiro com get_text
			var_aux.clear();
			var_aux= this->TB_Obs->get_text();
			SQL += var_aux + "' )";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			//cout<<"testando a porra da inserção na temp"<<sql<<endl;
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			}
		visualizacao_treeview (); //recarregar as informações nas treeviews
		limpar_janela();  //zerar todas as entrys
		}
	else
		{
		Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
		Confirma.set_secondary_text("Observe se as informações: Numero Planilha, Data Revisão, Colmeia, Abelha Rainha estão corretas!");
		Confirma.set_position(Gtk::WIN_POS_CENTER);
		Confirma.run();
		this->Historico_Producao.set_focus(ent_Colmeia);
		}
	}

/**
 * 
 */
void HISTORICO :: abrir_janela()
	{
	char *sql;
	string SQL, auxiliaridapi;
	int i, j, cont;
	Gtk::TreeModel::Row registro;
	Gtk::TreeModel::iterator contador;
	
	//Para saber qual janela será aberta
	contador = this->CB_Opcao.get_active();
	if(contador)
		{
		registro=*contador;
		if(registro)
			{
			this->cod_janela=registro[Planilha_Reg.reg];
			}
		}
	//itoa(this->tipo_planilha,aux,10);
	switch (this->cod_janela)
		{
		case 1:
			{			
			if(this->ent_apiario.get_text_length() > 10)
				{
				
				auxiliaridapi.clear();
				auxiliaridapi = ent_apiario.get_text();
				i = auxiliaridapi.find('<');
				if (i != string::npos)
					{
					j = auxiliaridapi.find('>');
					}
					
				cod_apiario= new char [32];
				strcpy(cod_apiario,auxiliaridapi.substr(i+1,j-i-1).c_str());
				SQL.clear();
				SQL = "select * from cadastro.apiarios where id_api="+auxiliaridapi.substr(i+1,j-i-1);
				sql = new char[SQL.length()+1];
				strcpy(sql,SQL.c_str());
				cout<<sql<<endl;
				this->conexao->executar(sql);
				delete sql;
				if(this->conexao->registros == 0)
					{
					Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
					Confirma.set_secondary_text("Entre com o Nome do Apiario!!");
					Confirma.set_position(Gtk::WIN_POS_CENTER);
					Confirma.run();
					this->Historico_Geral.set_focus(ent_apiario);
					}
				else
					{
					this->Historico_Geral.hide();
					janela_producao ();
					Gtk::Main::run(Historico_Producao);
					//Historico_Producao.set_focus(ent_Nump);
					visualizacao_treeview ();
					}
				}
			else
				{
				Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
				Confirma.set_secondary_text("Entre com o Nome do Apiario!!");
				Confirma.set_position(Gtk::WIN_POS_CENTER);
				Confirma.run();
				this->Historico_Geral.set_focus(ent_apiario);
				}
			break;
			}
		case 2:
			{
			if(this->ent_apiario.get_text_length() > 0)
				{
				auxiliaridapi.clear();
				auxiliaridapi = ent_apiario.get_text();
				i = auxiliaridapi.find('<');
				if (i != string::npos)
					{
					j = auxiliaridapi.find('>');
					}
				cod_apiario= new char [32];
				strcpy(cod_apiario,auxiliaridapi.substr(i+1,j-i-1).c_str());
				SQL.clear();
				SQL = "select * from cadastro.apiarios where id_api="+auxiliaridapi.substr(i+1,j-i-1);
				cout<<sql<<endl;
				this->conexao->executar(sql);
				delete sql;
				if(this->conexao->registros == 0)
					{
					Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
					Confirma.set_secondary_text("Entre com o Nome do Apiario!!");
					Confirma.set_position(Gtk::WIN_POS_CENTER);
					Confirma.run();
					this->Historico_Geral.set_focus(ent_apiario);
					}
				else
					{
					this->Historico_Geral.hide();
					Gtk::Main::run(Historico_Desenvolvimento);
					}
				}
			else
				{
				Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
				Confirma.set_secondary_text("Entre com o Nome do Apiario!!");
				Confirma.set_position(Gtk::WIN_POS_CENTER);
				Confirma.run();
				this->Historico_Geral.set_focus(ent_apiario);
				}
			break;
			}
		}
	}

/**
 *
 */
void HISTORICO :: visualizacao_treeview ()
	{
	char *sql, *aux;
	int total_reg, total_col, i, j, nota, situacao;
	string SQL, aux_a, contador_colmeia;
	vector<vector<string> >::iterator ir;
	vector<string> linha;

	ponteiro_lista = Gtk::ListStore::create(Planilha_Reg);
	CT_Historico.set_model(ponteiro_lista);
	//Gtk::TreeModel::Row coluna;

	/*	strcpy(sql,"select count(*) from historico.producaotemp where id_apiario=");
	strcat(sql, cod_apiario);  //Pegando numero do Apiario
	this->executar(sql,0);
	this->total_geral = atoi(this->resultado(0,0));
	this->paginas = (int) ceil(this->total_geral/this->limite);
	this->offset = this->pagina_apicol * this->limite;
	this->total_apicol= this->paginas;
	this->pos_atual=this->pagina_apicol;
	this->pos_atual=pos_atual+1;
	sprintf(aux,"Registro nº: %d / %d", pos_atual, this->total_apicol+1);
	this->navegacaoapiario.set_text (Glib::ustring(aux));
	contador_colmeia ="<span font='12'><i><b>Total de Colmeias: ";
		//contador_colmeia+=this->resultado(0,0);
		//contador_colmeia+="</b></i></span> ";
		//enttotalcolmeias.set_markup(contador_colmeia);*/	
	SQL.clear();
	SQL = "select id_planilha, id_colmeia, data_formacao, data_revisao, horai, horaf, melg_colh, total_kg_colh, melg_remanes, kg_remanes, nota, rainha, geracao, cod_mae, data_introducao, situacao, obs from historico.producaotemp where id_apiario= ";
	SQL.append(cod_apiario);
		//strcat(sql, " order by data_revisao desc");
		//cout<<"teste offset e sql	 "<<offset<<endl<<sql<<endl;
	sql = new char[SQL.length()+1];
	strcpy(sql, SQL.c_str());
	this->conexao->executar(sql);
	delete sql;
		//cout<<"teste o sql do temp 2222  "<<sql<<endl;
	total_reg=this->conexao->registros;
	total_col=this->conexao->colunas;
		//cout<<"Total coluna "<<this->total_colunas<<" "<<this->total_registros<<endl;
	this->conexao->resultado();
	for (ir=this->conexao->resultados.begin(); ir < this->conexao->resultados.end(); ir++)
		{
		linha = *ir;
		celula = *(ponteiro_lista->append());
		celula[Planilha_Reg.reg] = i;
		//cout<<"Teste do I    "<<i<<endl;
		for(j=0;j<total_col;j++)
			{
			switch(j)
				{
				/*	case 0:
						{
						coluna[Planilha_Reg.campo[j]]=this->resultado(i,j);
						break;
						}
					case 1:
						{
						coluna[Planilha_Reg.campo[j]]=this->resultado(i,j);
						break;
						}*/
				case 2:
					{
					aux = new char[32];
					strcpy(aux,linha.at(j).c_str());
					celula[Planilha_Reg.campo[j]]= data_formatada(aux, 2);
					delete aux;
					break;
					}
				case 3:
					{
					aux = new char[32];
					strcpy(aux,linha.at(j).c_str());
					celula[Planilha_Reg.campo[j]]= data_formatada(aux, 2);
					delete aux;
					break;
					}
				case 10:
					{
					nota = atoi(linha.at(j).c_str());
					switch (nota)
						{
						case 1:
							{
							celula[Planilha_Reg.campo[j]]="Ótima";
							break;
							}
						case 2:
							{
							celula[Planilha_Reg.campo[j]]="Boa";
							break;
							}
						case 3:
							{
							celula[Planilha_Reg.campo[j]]="Ruim";
							break;
							}
						case 4:
							{
							celula[Planilha_Reg.campo[j]]="Avaliar";
							break;
							}
						}
					break;
					}
				case 14:
					{
					aux = new char[32];
					strcpy(aux,linha.at(j).c_str());
					celula[Planilha_Reg.campo[j]]= data_formatada(aux, 2);
					delete aux;
					break;
					}
				case 15:
					{
					situacao = atoi(linha.at(j).c_str());
					switch (situacao)
						{
						case 1:
							{
							celula[Planilha_Reg.campo[j]]="Puxada Natural";
							break;
							}
						case 2:
							{
							celula[Planilha_Reg.campo[j]]="Zanganeira";
							break;
							}
						case 3:
							{
							celula[Planilha_Reg.campo[j]]="Enxameação";
							break;
							}
						case 4:
							{
							celula[Planilha_Reg.campo[j]]="Rainha Fecundada";
							break;
							}
						case 5:
							{
							celula[Planilha_Reg.campo[j]]="Trocar Rainha";
							break;
							}
						}
					break;
					}
						
				default:
					{
					celula[Planilha_Reg.campo[j]]= linha.at(j);
					break;
					}
				}
			}
		}
	
//*********************************Até aqui tava funcionando!************************************************************


//Glib::RefPtr<Gtk::EntryCompletion> completion =  Gtk::EntryCompletion::create();

//entServico.set_completion(completion);

	CT_Historico.remove_all_columns();
	CT_Historico.append_column(Glib::ustring("Nº Plan"), Planilha_Reg.campo[0]);
	CT_Historico.append_column(Glib::ustring("Colmeia"), Planilha_Reg.campo[1]);
	CT_Historico.append_column(Glib::ustring("Data de Formação"), Planilha_Reg.campo[2]);
	CT_Historico.append_column(Glib::ustring("Data de Revisão"), Planilha_Reg.campo[3]);

	CT_Historico.append_column(Glib::ustring("Hora Inicial"), Planilha_Reg.campo[4]);
	CT_Historico.append_column(Glib::ustring("Hora Final"), Planilha_Reg.campo[5]);
	CT_Historico.append_column(Glib::ustring("Nº Melg. Colh."), Planilha_Reg.campo[6]);
	CT_Historico.append_column(Glib::ustring("Total KG"), Planilha_Reg.campo[7]);

	CT_Historico.append_column(Glib::ustring("Melg. Remanes."), Planilha_Reg.campo[8]);
	CT_Historico.append_column(Glib::ustring("KG Remanes."), Planilha_Reg.campo[9]);
	CT_Historico.append_column(Glib::ustring("Nota Colmeia"), Planilha_Reg.campo[10]);
	CT_Historico.append_column(Glib::ustring("Rainha"), Planilha_Reg.campo[11]);

	CT_Historico.append_column(Glib::ustring("Geração"), Planilha_Reg.campo[12]);
	CT_Historico.append_column(Glib::ustring("Mãe"), Planilha_Reg.campo[13]);
	CT_Historico.append_column(Glib::ustring("Data Introdução."), Planilha_Reg.campo[14]);
	CT_Historico.append_column(Glib::ustring("Situação"), Planilha_Reg.campo[15]);
	CT_Historico.append_column(Glib::ustring("OBS"), Planilha_Reg.campo[16]);


	//FAZ COM QUE TODAS AS COLUNAS FIQUEM REORDENÁVEIS
	for(i=0; i < 16; i++)
		{
		Gtk::TreeView::Column* coluna_temp = CT_Historico.get_column(i);
		coluna_temp->set_reorderable();
		}
	CT_Historico.signal_row_activated().connect(sigc::mem_fun(*this,&HISTORICO::selecionado));
	}

/**
 *
 */
void HISTORICO :: limpar_janela ()
	{
	ent_Nump.set_text("");
	ent_DataRev.set_text("");
	ent_Horai.set_text("");
	ent_Horaf.set_text("");
	ent_Colmeia.set_text("");
	ent_melgueiracol.set_text("");
	ent_totalkg.set_text("");
	ent_melgremanes.set_text("");
	ent_kgremanes.set_text("");
	CB_Nota.set_active(0);
	ent_rainha.set_text("");
	ent_geracao.set_text("");
	ent_mae.set_text("");
	ent_intro.set_text("");
	CB_Situacao.set_active(0);
	this->TB_Obs = Gtk::TextBuffer::create ();
	this->TB_Obs->set_text("");
	this->TV_obs.set_buffer(this->TB_Obs);
	}

/**
 * \param path
 * \param column
 */
void HISTORICO::selecionado(const Gtk::TreeModel::Path& path,Gtk::TreeViewColumn* column)
	{
	//limpar_janela();
	Gtk::TreeModel::iterator contador;
	Gtk::TreeModel::Row registro;
	int i;
	Glib::ustring aux;
	char *aux2;
	//this->resposta=true;
	//this->controle=false;
	contador = ponteiro_lista->get_iter(path);

	if(contador)
		{
		registro=*contador;
		if(registro)
			{
			//cout<<"ta vindo até aqui  "<<registro[Planilha_Reg.reg]<<endl;
			//this->ent_Nump.set_text(registro[Planilha_Reg.campo[0]]);
			//this->ent_DataRev.set_text(registro[Planilha_Reg.campo[3]]);
			aux.clear();
			aux=(registro[Planilha_Reg.campo[4]]);
			this->ent_Horai.set_text(aux);
			this->ent_Horaf.set_text(registro[Planilha_Reg.campo[5]]);
				
			aux.clear();
			this->cod_registro= registro[Planilha_Reg.reg];
			aux2 = new char [aux.length()+11];
			aux=(registro[Planilha_Reg.campo[1]]);
			strcpy(aux2,aux.c_str());
			aux.clear();
			aux=(registro[Planilha_Reg.campo[2]]);
			strcat(aux2,"  ");
			strcat(aux2,aux.c_str());
			ent_Colmeia.set_text(aux2);
			delete aux2;
			this->ent_melgueiracol.set_text(registro[Planilha_Reg.campo[6]]);
			this->ent_totalkg.set_text(registro[Planilha_Reg.campo[7]]);
			this->ent_melgremanes.set_text(registro[Planilha_Reg.campo[8]]);
			this->ent_kgremanes.set_text(registro[Planilha_Reg.campo[9]]);
		
			if(registro[Planilha_Reg.campo[10]]=="Ótima")
				{
				CB_Nota.set_active(1);
				}
			else
				{
				if(registro[Planilha_Reg.campo[10]]=="Boa")
					{
					CB_Nota.set_active(2);
					}
				else
					{
					if(registro[Planilha_Reg.campo[10]]=="Ruim")
						{
						CB_Nota.set_active(3);
						}
					else
						{
						if(registro[Planilha_Reg.campo[10]]=="Avaliar")
							{
							CB_Nota.set_active(4);
							}
						}
					}
				}
			this->ent_rainha.set_text(registro[Planilha_Reg.campo[11]]);
			this->ent_geracao.set_text(registro[Planilha_Reg.campo[12]]);
			this->ent_mae.set_text(registro[Planilha_Reg.campo[13]]);
			this->ent_intro.set_text(registro[Planilha_Reg.campo[14]]);
		
			if(registro[Planilha_Reg.campo[15]]=="Puxada Natural")
				{
				CB_Situacao.set_active(1);
				}
			else
				{
				if(registro[Planilha_Reg.campo[15]]=="Zanganeira")
					{
					CB_Situacao.set_active(2);
					}
				else
					{
					if(registro[Planilha_Reg.campo[15]]=="Enxameação")
						{
						CB_Situacao.set_active(3);
						}
					else
						{
						if(registro[Planilha_Reg.campo[15]]=="Rainha Fecundada")
							{
							CB_Situacao.set_active(4);
							}
						else
							{
							if(registro[Planilha_Reg.campo[15]]=="Trocar Rainha")
								{
								CB_Situacao.set_active(5);
								}
							}
						}
					}
				}
			this->TB_Obs = Gtk::TextBuffer::create ();
			this->TB_Obs->set_text(registro[Planilha_Reg.campo[16]]);
			this->TV_obs.set_buffer(this->TB_Obs);
					//cout<<"ta vindo até aqui 12321321 "<<endl;
			}
		}
	}
